package com.xf.leecode;

import com.xf.leecode.bean.Good;
import org.junit.Test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

/**
 * @author zouxf Department:3cs
 * @create Date 2022/7/21 21:50
 * @description
 * @lastModifiedBy
 * @lastModifiedDate(yyyy/MM/dd)
 * @see
 */
public class HJQuestion {
    /**
     * ====================HJ0 字符串最后一个单词的长度=====================
     * 描述
     * 计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
     * 输入描述：
     * 输入一行，代表要计算的字符串，非空，长度小于5000。
     * <p>
     * 输出描述：
     * 输出一个整数，表示输入字符串最后一个单词的长度。
     */
    @Test
    public void test0() {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        int length = str.length();
        int count = 0;
        for (int i = length - 1; i >= 0; i--) {
            if (str.charAt(i) == ' ') { // 或者 if (str.substring(i, i + 1).equals(" ")) {
                break;
            }
            count++;
        }
        System.out.println(count);
    }

    char toLower(char c) {
        if (c >= 65 && c <= 90) {
            c += 32;
        }
        return c;
    }

    /**
     * ================HJ1 明明的随机数======================
     * 描述
     * 明明生成了NN个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。
     * <p>
     * 数据范围： 1 \le n \le 1000 \1≤n≤1000  ，输入的数字大小满足 1 \le val \le 500 \1≤val≤500
     * 输入描述：
     * 第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。
     * 输出描述：
     * 输出多行，表示输入数据处理后的结果
     */
    @Test
    public void test1() {
        Scanner sc = new Scanner(System.in);
        //获取个数
        int num = sc.nextInt();
        //创建TreeSet进行去重排序
        TreeSet set = new TreeSet();
        //输入
        for (int i = 0; i < num; i++) {
            set.add(sc.nextInt());
        }

        //输出
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    /**
     * ================HJ2 计算某字符出现次数======================
     * 写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字符，然后输出输入字符串中该字符的出现次数。（不区分大小写字母）
     * <p>
     * 数据范围： 1 \le n \le 1000 \1≤n≤1000
     * 第一行输入一个由字母和数字以及空格组成的字符串，第二行输入一个字符。
     * <p>
     * 输出描述：
     * 输出输入字符串中含有该字符的个数。（不区分大小写字母）
     */
    @Test
    public void test2() {
        Scanner in = new Scanner(System.in);
        char[] cs1 = "aXasxaawAXsaAaA".toCharArray();
        char c = "A".charAt(0);
        for (int i = 0; i < cs1.length; i++) {
            cs1[i] = toLower(cs1[i]);
        }
        c = toLower(c);
        int num = 0;
        for (int i = 0; i < cs1.length; i++) {
            if (cs1[i] == c) {
                num++;
            }
        }
        System.out.print(num);
    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test3() {
        Scanner sc = new Scanner(System.in);
        //获取个数
        int num = 10;//sc.nextInt();
        //创建TreeSet进行去重排序
        TreeSet set = new TreeSet();
        set.add(2);
        set.add(3);
        set.add(11);
        set.add(11);
        set.add(2);
        //输入
        for (int i = 0; i < num; i++) {
            set.add(1);
//            set.add(sc.nextInt());
        }

        //输出
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

    /**
     * ================HJ4 字符串分隔======================
     * •输入一个字符串，请按长度为8拆分每个输入字符串并进行输出；
     * <p>
     * •长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
     * 示例1
     * 输入：
     * abc
     * 输出：
     * abc00000
     */
    @Test
    public void test4() {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()) {
            String str = sc.nextLine();
            StringBuilder sb = new StringBuilder();//牢记字符串缓冲区的建立语法
            sb.append(str);//字符串缓冲区的加入
            int size = str.length();
            int addZero = 8 - size % 8;//addzero的可能值包括8
            while ((addZero > 0) && (addZero < 8)) {//注意边界调节，避免addzero=8
                sb.append("0");//使用‘’或“”都可
                addZero--;
            }
            String str1 = sb.toString();
            while (str1.length() > 0) {
                System.out.println(str1.substring(0, 8));
                str1 = str1.substring(8);
            }

        }
    }

    /**
     * ================HJ5 进制转换======================
     * 写出一个程序，接受一个十六进制的数，输出该数值的十进制表示。
     * <p>
     * 数据范围：保证结果在 1 \le n \le 2^{31}-1 \1≤n≤2
     * 31
     * −1
     * 对ASCII码表的掌握
     */
    @Test
    public void test5() {
        String str16 = "FF5";
        char[] chars = str16.toCharArray();
        int s = chars.length - 1;
        int result = 0;
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            int num10 = 0;
            if (c >= '0' && c <= '9') {
                num10 = c - '0';
            }
            if (c >= 'A' && c <= 'F') {
                num10 = c - 'A' + 10;
            }
            double pow = Math.pow(16, s--);
            result += pow * num10;
        }
        System.out.println(result);
        System.out.println(Integer.parseInt("FFF", 16));
       /* Scanner sc = new Scanner(System.in);
        while(sc.hasNextLine()){
            String s = sc.nextLine();
            System.out.println(Integer.parseInt(s.substring(2,s.length()),16));
        }*/
    }

    /**
     * ================HJ6 质数因子======================
     * 描述
     * 功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
     * <p>
     * <p>
     * 数据范围： 1 \le n \le 2 \times 10^{9} + 14 \1≤n≤2×10
     * 9
     * +14
     * 输入描述：
     * 输入一个整数
     * <p>
     * 输出描述：
     * 按照从小到大的顺序输出它的所有质数的因子，以空格隔开。
     */
    @Test
    public void test6() {
        Scanner scanner = new Scanner(System.in);

        long num = scanner.nextLong();
        long k = (long) Math.sqrt(num);

        for (long i = 2; i <= k; ++i) {
            while (num % i == 0) {
                System.out.print(i + " ");
                num /= i;
            }
        }
        System.out.println(num == 1 ? "" : num + " ");
    }

    /**
     * ================HJ7 取近似值======================
     */
    @Test
    public void test7() {
        Scanner in = new Scanner(System.in);
        double number = in.nextDouble();
        System.out.println((int) (number + 0.5));
    }

    /**
     * ================HJ8 合并表记录======================
     * 描述
     * 数据表记录包含表索引index和数值value（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照index值升序进行输出。
     *
     *
     * 提示:
     * 0 <= index <= 11111111
     * 1 <= value <= 100000
     *
     * 输入描述：
     * 先输入键值对的个数n（1 <= n <= 500）
     * 接下来n行每行输入成对的index和value值，以空格隔开
     *
     * 输出描述：
     * 输出合并后的键值对（多行）
     */
    @Test
    public void test8() {
        Scanner scanner = new Scanner(System.in);
        int tableSize = scanner.nextInt();
        Map<Integer, Integer> table = new HashMap<>(tableSize);
        for (int i = 0; i < tableSize; i++) {
            int key = scanner.nextInt();
            int value = scanner.nextInt();
            if (table.containsKey(key)) {
                table.put(key, table.get(key) + value);
            } else {
                table.put(key, value);
            }
        }
        for (Integer key : table.keySet()) {
            System.out.println(key + " " + table.get(key));
        }
    }

    /**
     * ================HJ9 提取不重复的整数======================
     * 描述
     * 输入一个 int 型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
     * 保证输入的整数最后一位不是 0 。
     *
     * 数据范围： 1 \le n \le 10^{8} \1≤n≤10
     * 8
     *
     * 输入描述：
     * 输入一个int型整数
     *
     * 输出描述：
     * 按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
     *
     * 示例1
     * 输入：
     * 9876673
     * 复制
     * 输出：
     * 37689
     */
    @Test
    public void test9() {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            // 使用HashSet来判断是否是不重复的
            HashSet<Integer> hs = new HashSet<>();
            int target = sc.nextInt();// 获取代求解的值
            while (target != 0) { // 求解每位上面的整数
                int temp = target % 10;
                if (hs.add(temp)) // 如果能加入，就是说明没有重复
                    System.out.print(temp);
                target /= 10;// 除10能去掉最右边的数字
            }
            System.out.println();
        }
    }

    /**
     * ================HJ10 字符个数统计======================
     * 描述
     * 编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ，包括 0 和 127 )，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
     * 例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
     *
     * 数据范围： 1 \le n \le 500 \1≤n≤500
     * 输入描述：
     * 输入一行没有空格的字符串。
     *
     * 输出描述：
     * 输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
     */
    @Test
    public void test10() {
        Scanner scanner = new Scanner(System.in);
        String line = scanner.next();
        //总共有128个字符。字需要用128位
        BitSet bitSet = new BitSet(128);
        for (char c : line.toCharArray()) {
            //判断字符c是否已出现
            if (!bitSet.get(c)) {
                //未出现就设置为已出现
                bitSet.set(c);
            }
        }
        //统计有多少字符已出现过
        System.out.println(bitSet.cardinality());
    }

    /**
     * ================HJ11 数字颠倒======================
     * 描述
     * 输入一个整数，将这个整数以字符串的形式逆序输出
     * 程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
     *
     *
     * 数据范围： 0 \le n \le 2^{30}-1 \0≤n≤2
     * 30
     *  −1
     * 输入描述：
     * 输入一个int整数
     *
     * 输出描述：
     * 将这个整数以字符串的形式逆序输出
     */
    @Test
    public void test11() {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        StringBuffer strb = new StringBuffer(str);
        strb.reverse();
        System.out.println(strb.toString());
    }

    /**
     * ================HJ12 字符串反转======================
     * 描述
     * 接受一个只包含小写字母的字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）
     *
     * 输入描述：
     * 输入一行，为一个只包含小写字母的字符串。
     *
     * 输出描述：
     * 输出该字符串反转后的字符串。
     *
     * 示例1
     * 输入：
     * abcd
     * 复制
     * 输出：
     * dcba
     */
    @Test
    public void test12() {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        StringBuffer strb = new StringBuffer(str);
        strb.reverse();
        System.out.println(strb.toString());
    }

    /**
     * ================HJ13 句子逆序======================
     * 描述
     * 将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
     *
     * 所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
     *
     * 数据范围：输入的字符串长度满足 1 \le n \le 1000 \1≤n≤1000
     *
     * 注意本题有多组输入
     * 输入描述：
     * 输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。
     *
     * 输出描述：
     * 得到逆序的句子
     *
     * 示例1
     * 输入：
     * I am a boy
     * 复制
     * 输出：
     * boy a am I
     * 复制
     * 示例2
     * 输入：
     * nowcoder
     * 复制
     * 输出：
     * nowcoder
     */
    @Test
    public void test13() {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        String s[] = str.split(" ");
        for (int i = s.length - 1; i >= 0; i--)
            if (i != 0)
                System.out.print(s[i] + " ");
            else
                System.out.print(s[i]);
    }

    /**
     * ================HJ14 字符串排序======================
     * 描述
     * 给定 n 个字符串，请对 n 个字符串按照字典序排列。
     *
     * 数据范围： 1 \le n \le 1000 \1≤n≤1000  ，字符串长度满足 1 \le len \le 100 \1≤len≤100
     * 输入描述：
     * 输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
     * 输出描述：
     * 数据输出n行，输出结果为按照字典序排列的字符串。
     */
    @Test
    public void test14() {

    }

    /**
     * ================HJ15 求int型正整数在内存中存储时1的个数======================
     * 描述
     * 输入一个 int 型的正整数，计算出该 int 型数据在内存中存储时 1 的个数。
     *
     * 数据范围：保证在 32 位整型数字范围内
     * 输入描述：
     *  输入一个整数（int类型）
     *
     * 输出描述：
     *  这个数转换成2进制后，输出1的个数
     */
    @Test
    public void test15() {
        Scanner in = new Scanner(System.in);
        int num = in.nextInt();    //读取数字
        int n = 0;    //计数变量
        for (int i = 0; i < 32; i++) {
            if ((num & 1) == 1)    //如果末位为1则计数
                n++;
            num = num >>> 1;    //无符号右移
        }
        System.out.println(n);
    }

    /**
     * ================HJ16 购物单======================
     * 描述
     * 王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
     * 主件	附件
     * 电脑	打印机，扫描仪
     * 书柜	图书
     * 书桌	台灯，文具
     * 工作椅	无
     * 如果要买归类为附件的物品，必须先买该附件所属的主件，且每件物品只能购买一次。
     * 每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。
     * 王强查到了每件物品的价格（都是 10 元的整数倍），而他只有 N 元的预算。除此之外，他给每件物品规定了一个重要度，用整数 1 ~ 5 表示。他希望在花费不超过 N 元的前提下，使自己的满意度达到最大。
     * 满意度是指所购买的每件物品的价格与重要度的乘积的总和，假设设第ii件物品的价格为v[i]v[i]，重要度为w[i]w[i]，共选中了kk件物品，编号依次为j_1,j_2,...,j_kj
     * 请你帮助王强计算可获得的最大的满意度。
     * 输入描述：
     * 输入的第 1 行，为两个正整数N，m，用一个空格隔开：
     * （其中 N （ N<32000 ）表示总钱数， m （m <60 ）为可购买的物品的个数。）
     * 从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q
     * （其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）
     * 输出描述：
     *  输出一个正整数，为张强可以获得的最大的满意度。
     50 5
     20 3 5
     20 3 5
     10 3 0
     10 2 0
     10 1 0

     130
     */
    @Test
    public void test16() {
        int n = 50;
        int m = 5;
        Good g1 = new Good(20, 3, 5);
        Good g2 = new Good(20, 3, 5);
        Good g3 = new Good(10, 3, 0);
        Good g4 = new Good(10, 2, 0);
        Good g5 = new Good(10, 1, 0);

        List<List<Good>> allRoute = new ArrayList<>();

        Boolean b = false;
        System.out.println(b);
        b = true;
        System.out.println(b);
    }

    /**
     * ================HJ17 坐标移动======================
     * 描述
     * 开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。
     *
     * 输入：
     *
     * 合法坐标为A(或者D或者W或者S) + 数字（两位以内）
     *
     * 坐标之间以;分隔。
     *
     * 非法坐标点需要进行丢弃。如AA10;  A1A;  $%$;  YAD; 等。
     *
     * 下面是一个简单的例子 如：
     *
     * A10;S20;W10;D30;X;A1A;B10A11;;A10;
     *
     * 处理过程：
     *
     * 起点（0,0）
     *
     * +   A10   =  （-10,0）
     *
     * +   S20   =  (-10,-20)
     *
     * +   W10  =  (-10,-10)
     *
     * +   D30  =  (20,-10)
     *
     * +   x    =  无效
     *
     * +   A1A   =  无效
     *
     * +   B10A11   =  无效
     *
     * +  一个空 不影响
     *
     * +   A10  =  (10,-10)
     *
     * 结果 （10， -10）
     *
     * 数据范围：每组输入的字符串长度满足 1\le n \le 10000 \1≤n≤10000  ，坐标保证满足 -2^{31} \le x,y \le 2^{31}-1 \−2
     * 31
     *  ≤x,y≤2
     * 31
     *  −1  ，且数字部分仅含正数
     * 输入描述：
     * 一行字符串
     *
     * 输出描述：
     * 最终坐标，以逗号分隔
     */
    @Test
    public void test17() throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] in = bf.readLine().split(";");
        int x = 0;
        int y = 0;
        for (String s : in) {
            // 不满足题目给定坐标规则
            if (!s.matches("[WASD][0-9]{1,2}")) {
                continue;
            }
            int val = Integer.valueOf(s.substring(1));
            switch (s.charAt(0)) {
                case 'W':
                    y += val;
                    break;
                case 'S':
                    y -= val;
                    break;
                case 'A':
                    x -= val;
                    break;
                case 'D':
                    x += val;
                    break;
            }
        }
        System.out.println(x + "," + y);
    }

    /**
     * ================HJ18 识别有效的IP地址和掩码并进行分类统计======================
     * 描述
     * 请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。
     *
     * 所有的IP地址划分为 A,B,C,D,E五类
     *
     * A类地址从1.0.0.0到126.255.255.255;
     *
     * B类地址从128.0.0.0到191.255.255.255;
     *
     * C类地址从192.0.0.0到223.255.255.255;
     *
     * D类地址从224.0.0.0到239.255.255.255；
     *
     * E类地址从240.0.0.0到255.255.255.255
     *
     *
     * 私网IP范围是：
     *
     * 从10.0.0.0到10.255.255.255
     *
     * 从172.16.0.0到172.31.255.255
     *
     * 从192.168.0.0到192.168.255.255
     *
     *
     * 子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）
     * （注意二进制下全是1或者全是0均为非法子网掩码）
     *
     * 注意：
     * 1. 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略
     * 2. 私有IP地址和A,B,C,D,E类地址是不冲突的
     *
     * 输入描述：
     * 多行字符串。每行一个IP地址和掩码，用~隔开。
     *
     * 请参考帖子https://www.nowcoder.com/discuss/276处理循环输入的问题。
     * 输出描述：
     * 统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。
     */
    @Test
    public void test18() {

    }

    /**
     * ================HJ19 简单错误记录======================
     * 描述
     * 开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。
     *
     *
     * 处理：
     *
     *
     * 1、 记录最多8条错误记录，循环记录，最后只用输出最后出现的八条错误记录。对相同的错误记录只记录一条，但是错误计数增加。最后一个斜杠后面的带后缀名的部分（保留最后16位）和行号完全匹配的记录才做算是“相同”的错误记录。
     * 2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；
     * 3、 输入的文件可能带路径，记录文件名称不能带路径。也就是说，哪怕不同路径下的文件，如果它们的名字的后16个字符相同，也被视为相同的错误记录
     * 4、循环记录时，只以第一次出现的顺序为准，后面重复的不会更新它的出现时间，仍以第一次为准
     *
     * 数据范围：错误记录数量满足 1 \le n \le 100 \1≤n≤100  ，每条记录长度满足 1 \le len \le 100 \1≤len≤100
     * 输入描述：
     * 每组只包含一个测试用例。一个测试用例包含一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。
     *
     * 输出描述：
     * 将所有的记录统计并将结果输出，格式：文件名 代码行数 数目，一个空格隔开，如：
     */
    @Test
    public void test19() throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        Map<String, Integer> map = new LinkedHashMap();
        String tstr = null;
        while ((tstr = bf.readLine()) != null && !tstr.equals("")) {
            String[] str = tstr.split("\\s+");
            String fname = str[0].substring(str[0].lastIndexOf("\\") + 1);
            fname = fname.substring(Math.max(fname.length() - 16, 0)) + " " + str[1];
            Integer tmp = map.get(fname);
            if (tmp == null)
                map.put(fname, 1);
            else
                map.put(fname, tmp + 1);
        }
        int count = 0;
        for (Map.Entry<String, Integer> it : map.entrySet()) {
            if (map.size() - count <= 8)
                System.out.println(it.getKey() + " " + it.getValue());
            count++;
        }
    }

    /**
     * ================HJ20 密码验证合格程序======================
     * 描述
     * 密码要求:
     *
     * 1.长度超过8位
     *
     * 2.包括大小写字母.数字.其它符号,以上四种至少三种
     *
     * 3.不能有长度大于2的包含公共元素的子串重复 （注：其他符号不含空格或换行）
     *
     * 数据范围：输入的字符串长度满足 1 \le n \le 100 \1≤n≤100
     * 输入描述：
     * 一组字符串。
     *
     * 输出描述：
     * 如果符合要求输出：OK，否则输出NG
     */
    @Test
    public void test20() {

    }

    /**
     * ================HJ21 简单密码======================
     */
    @Test
    public void test21() {

    }

    /**
     * ================HJ22 汽水瓶======================
     */
    @Test
    public void test22() {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()) {
            int bottle = sc.nextInt();
            if (bottle == 0) {
                break;
            }
            System.out.println(bottle / 2);
        }
    }

    /**
     * ================HJ23 删除字符串中出现次数最少的字符======================
     */
    @Test
    public void test23() {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String str = in.nextLine();
            String res = this.delete(str);
            System.out.println(res);
        }
    }

    public String delete(String str) {
        // Map记录每个字母的次数
        Map<Character, Integer> map = new HashMap<>();
        for (char ch : str.toCharArray()) {
            map.put(ch, map.getOrDefault(ch, 0) + 1);
        }
        // 快速找出最少次数
        int min = Integer.MAX_VALUE;
        for (int times : map.values()) {
            min = Math.min(min, times);
        }
        StringBuilder res = new StringBuilder();
        for (char ch : str.toCharArray()) {
            if (map.get(ch) != min) {
                res.append(ch);
            }
        }
        return res.toString();
    }

    /**
     * ================HJ24 合唱队======================
     */
    @Test
    public void test24() {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextInt()) {
            int n = sc.nextInt();
            int[] arr = new int[n];
            int[] arrL = new int[n]; // 左侧小于arr[i]的个数
            int[] arrR = new int[n]; // 右侧大于arr[i]的个数
            for (int i = 0; i < n; ++i) {
                arr[i] = sc.nextInt();
            }

            for (int i = 0; i < n; ++i) {
                arrL[i] = 0; // 所以默认初始是0,,对于第一个数来说， 在arr[0]的左侧小于arr[0]的个数是0。
                for (int j = 0; j < i; ++j) {
                    if (arr[i] > arr[j]) {
                        arrL[i] = Math.max(arrL[j] + 1, arrL[i]);
                    }
                }
            }

            for (int i = n - 1; i >= 0; --i) {
                arrR[i] = 0; // 所以默认初始是0,,对于最后一个数来说， 在arr[n - 1]的右侧小于arr[0]的个数是0。
                for (int j = n - 1; j > i; --j) {
                    if (arr[i] > arr[j]) {
                        arrR[i] = Math.max(arrR[j] + 1, arrR[i]);
                    }
                }
            }

            int maxValue = 0;
            for (int i = 0; i < n; ++i) {
                maxValue = Math.max(maxValue, arrR[i] + arrL[i] + 1);
            }

            System.out.println(n - maxValue);
        }
    }

    /**
     * ================HJ25 数据分类处理======================
     */
    @Test
    public void test25() {
/*
         根据题解可知：整数序列I 和 规则整数序列R
         1、是根据R中元素到I序列中进行匹配查询并将I序列中出现的R[i]的索引(index)和I[i]的值进行记录
         2、定义集合用于记录待查找条件R[i]和R[i]出现的次数(count),最后将第一步得到的集合放进来即可，此处也可使用StringBuffer
         */
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int In = scanner.nextInt(); //整数序列I的个数
            String[] I_arr = new String[In];
            for (int i = 0; i < In; i++) {
                I_arr[i] = String.valueOf(scanner.nextInt());
            }

            int Rn = scanner.nextInt();//规则整数序列R的个数
            Set<Integer> R_set = new TreeSet<>();//使用TreeSet进行排序和去重
            for (int i = 0; i < Rn; i++) {
                R_set.add(scanner.nextInt());
            }

            List<Integer> I_list = new ArrayList<>();//用于存储整数序列I
            List<Integer> R_list = new ArrayList<>();//用于存储规则整数序列R
            for (int item : R_set) {
                int count = 0;//统计R中元素在I中出现的次数
                for (int i = 0; i < I_arr.length; i++) {
                    if (I_arr[i].contains(String.valueOf(item))) {
                        count++;
                        I_list.add(i);
                        I_list.add(Integer.valueOf(I_arr[i]));
                    }
                }
                if (count > 0) {
                    R_list.add(item);
                    R_list.add(count);
                    R_list.addAll(I_list);
                }
                I_list.clear();
            }
            System.out.print(R_list.size() + " ");
            for (Integer i : R_list) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }

    /**
     * ================HJ26 字符串排序======================
     */
    @Test
    public void test26() {

    }

    /**
     * ================HJ27 查找兄弟单词======================
     */
    @Test
    public void test27() {

    }

    /**
     * ================HJ28 素数伴侣======================
     */
    @Test
    public void test28() {

    }

    /**
     * ================HJ29 字符串加解密======================
     */
    @Test
    public void test29() {

    }

    /**
     * ================HJ30 字符串合并处理======================
     */
    @Test
    public void test30() {
        //hash 保存十六进制反转的对应表， 空间换时间
        Map<Character, Character> map = new HashMap<Character, Character>() {{
            put('0', '0');
            put('1', '8');
            put('2', '4');
            put('3', 'C');
            put('4', '2');
            put('5', 'A');
            put('6', '6');
            put('7', 'E');
            put('8', '1');
            put('9', '9');
            put('a', '5');
            put('b', 'D');
            put('c', '3');
            put('d', 'B');
            put('e', '7');
            put('f', 'F');
            put('A', '5');
            put('B', 'D');
            put('C', '3');
            put('D', 'B');
            put('E', '7');
            put('F', 'F');
        }};

        Scanner scanner = new Scanner(System.in);
        String s = "";
        while (scanner.hasNext()) {
            String s1 = scanner.next();
            String s2 = scanner.next();
            char[] ch = (s1 + s2).toCharArray();
            //偶数位
            char[] r1 = new char[ch.length / 2];
            //奇数位
            char[] r2 = new char[ch.length - ch.length / 2];
            for (int i = 0, j = 0, k = 0; i < ch.length; i++) {
                if (i % 2 == 0) {
                    r2[j] = ch[i];
                    j++;
                } else {
                    r1[k] = ch[i];
                    k++;
                }
            }

            Arrays.sort(r1);
            Arrays.sort(r2);

            for (int i = 0, j = 0, k = 0; i < ch.length; i++) {
                if (i % 2 == 0) {
                    //注意存在码表不包含的情况，使用原值
                    ch[i] = map.getOrDefault(r2[j], r2[j]);
                    j++;
                } else {
                    ch[i] = map.getOrDefault(r1[k], r1[k]);
                    k++;
                }
            }

            s = new String(ch);
            System.out.println(s);

        }

    }

    /**
     * ================HJ31	单词倒排======================
     */
    @Test
    public void test31() {

    }

    /**
     * ================HJ32	密码截取======================
     */
    @Test
    public void test32() {

    }

    /**
     * ================HJ33	整数与IP地址间的转换======================
     */
    @Test
    public void test33() {

    }

    /**
     * ================HJ34	图片整理======================
     */
    @Test
    public void test34() {

    }

    /**
     * ================HJ35	蛇形矩阵======================
     */
    @Test
    public void test35() {

    }

    /**
     * ================HJ36	字符串加密======================
     */
    @Test
    public void test36() {

    }

    /**
     * ================HJ37	统计每个月兔子的总数======================
     */
    @Test
    public void test37() {

    }

    /**
     * ================HJ38	求小球落地5次后所经历的路程和第5次反弹的高度======================
     */
    @Test
    public void test38() {

    }

    /**
     * ================HJ39	判断两个IP是否属于同一子网======================
     */
    @Test
    public void test39() {

    }

    /**
     * ================HJ40	统计字符======================
     */
    @Test
    public void test40() {

    }

    /**
     * ================HJ41	称砝码======================
     */
    @Test
    public void test41() {

    }

    /**
     * ================HJ42	学英语======================
     */
    @Test
    public void test42() {

    }

    /**
     * ================HJ43	迷宫问题======================
     */
    @Test
    public void test43() {

    }

    /**
     * ================HJ44	Sudoku======================
     */
    @Test
    public void test44() {

    }

    /**
     * ================HJ45	名字的漂亮度======================
     */
    @Test
    public void test45() {

    }

    /**
     * ================HJ46	截取字符串======================
     */
    @Test
    public void test46() {

    }

    /**
     * ================HJ47 ======================
     */
    @Test
    public void test47() {

    }

    /**
     * ================HJ48	从单向链表中删除指定值的节点======================
     */
    @Test
    public void test48() {

    }

    /**
     * ================HJ49 ======================
     */
    @Test
    public void test49() {

    }

    /**
     * ================HJ50	四则运算======================
     */
    @Test
    public void test50() {

    }

    /**
     * ================HJ51	输出单向链表中倒数第k个结点======================
     */
    @Test
    public void test51() {

    }

    /**
     * ================HJ52	计算字符串的编辑距离======================
     */
    @Test
    public void test52() {

    }

    /**
     * ================HJ53	杨辉三角的变形======================
     */
    @Test
    public void test53() {

    }

    /**
     * ================HJ54	表达式求值======================
     */
    @Test
    public void test54() {

    }

    /**
     * ================HJ55	挑7======================
     */
    @Test
    public void test55() {

    }

    /**
     * ================HJ56	完全数计算======================
     */
    @Test
    public void test56() {

    }

    /**
     * ================HJ57	高精度整数加法======================
     */
    @Test
    public void test57() {

    }

    /**
     * ================HJ58	输入n个整数，输出其中最小的k个======================
     */
    @Test
    public void test58() {

    }

    /**
     * ================HJ59	找出字符串中第一个只出现一次的字符======================
     */
    @Test
    public void test59() {

    }

    /**
     * ================HJ60	查找组成一个偶数最接近的两个素数======================
     */
    @Test
    public void test60() {

    }

    /**
     * ================HJ61	放苹果======================
     */
    @Test
    public void test61() {

    }

    /**
     * ================HJ62	查找输入整数二进制中1的个数======================
     */
    @Test
    public void test62() {

    }

    /**
     * ================HJ63	DNA序列======================
     */
    @Test
    public void test63() {

    }

    /**
     * ================HJ64	MP3光标位置======================
     */
    @Test
    public void test64() {

    }

    /**
     * ================HJ65	查找两个字符串a,b中的最长公共子串======================
     */
    @Test
    public void test65() {

    }

    /**
     * ================HJ66	配置文件恢复======================
     */
    @Test
    public void test66() {

    }

    /**
     * ================HJ67	24点游戏算法======================
     */
    @Test
    public void test67() {

    }

    /**
     * ================HJ68	成绩排序======================
     */
    @Test
    public void test68() {

    }

    /**
     * ================HJ69	矩阵乘法======================
     */
    @Test
    public void test69() {

    }

    /**
     * ================HJ70	矩阵乘法计算量估算======================
     */
    @Test
    public void test70() {

    }

    /**
     * ================HJ71	字符串通配符======================
     */
    @Test
    public void test71() {

    }

    /**
     * ================HJ72	百钱买百鸡问题======================
     */
    @Test
    public void test72() {

    }

    /**
     * ================HJ73	计算日期到天数转换======================
     */
    @Test
    public void test73() {

    }

    /**
     * ================HJ74	参数解析======================
     */
    @Test
    public void test74() {

    }

    /**
     * ================HJ75	公共子串计算======================
     */
    @Test
    public void test75() {

    }

    /**
     * ================HJ76	尼科彻斯定理======================
     */
    @Test
    public void test76() {

    }

    /**
     * ================HJ77	火车进站======================
     */
    @Test
    public void test77() {

    }

    /**
     * ================HJ78 无======================
     */
    @Test
    public void test78() {

    }

    /**
     * ================HJ79 无======================
     */
    @Test
    public void test79() {

    }

    /**
     * ================HJ80	整型数组合并======================
     */
    @Test
    public void test80() {

    }

    /**
     * ================HJ81	字符串字符匹配======================
     */
    @Test
    public void test81() {

    }

    /**
     * ================HJ82	将真分数分解为埃及分数======================
     */
    @Test
    public void test82() {

    }

    /**
     * ================HJ83	二维数组操作======================
     */
    @Test
    public void test83() {

    }

    /**
     * ================HJ84	统计大写字母个数======================
     */
    @Test
    public void test84() {

    }

    /**
     * ================HJ85	最长回文子串======================
     */
    @Test
    public void test85() {

    }

    /**
     * ================HJ86	求最大连续bit数======================
     */
    @Test
    public void test86() {

    }

    /**
     * ================HJ87	密码强度等级======================
     */
    @Test
    public void test87() {

    }

    /**
     * ================HJ88	扑克牌大小======================
     */
    @Test
    public void test88() {

    }

    /**
     * ================HJ89	24点运算======================
     */
    @Test
    public void test89() {

    }

    /**
     * ================HJ90	合法IP======================
     */
    @Test
    public void test90() {

    }

    /**
     * ================HJ91	走方格的方案数======================
     */
    @Test
    public void test91() {

    }

    /**
     * ================HJ92	在字符串中找出连续最长的数字串======================
     */
    @Test
    public void test92() {

    }

    /**
     * ================HJ93	数组分组======================
     */
    @Test
    public void test93() {

    }

    /**
     * ================HJ94	记票统计======================
     */
    @Test
    public void test94() {

    }

    /**
     * ================HJ95	人民币转换======================
     */
    @Test
    public void test95() {

    }

    /**
     * ================HJ96	表示数字=====================
     */
    @Test
    public void test96() {

    }

    /**
     * ================HJ97	记负均正======================
     */
    @Test
    public void test97() {

    }

    /**
     * ================HJ98	自动售货系统======================
     */
    @Test
    public void test98() {

    }

    /**
     * ================HJ99	自守数======================
     */
    @Test
    public void test99() {

    }

    /**
     * ================HJ100	等差数列======================
     */
    @Test
    public void test100() {

    }

    /**
     * ================HJ101	输入整型数组和排序标识，对其元素按照升序或降序进行排序======================
     */
    @Test
    public void test101() {

    }

    /**
     * ================HJ102	字符统计======================
     */
    @Test
    public void test102() {

    }

    /**
     * ================HJ103	Redraiment的走法======================
     */
    @Test
    public void test103() {

    }

    /**
     * ================HJ104 无======================
     */
    @Test
    public void test104() {

    }

    /**
     * ================HJ105	记负均正II======================
     */
    @Test
    public void test105() {

    }

    /**
     * ================HJ106	字符逆序======================
     */
    @Test
    public void test106() {

    }

    /**
     * ================HJ107	求解立方根======================
     */
    @Test
    public void test107() {

    }

    /**
     * ================HJ108	求最小公倍数======================
     */
    @Test
    public void test108() {

    }

    /**
     * ================HJ109 无======================
     */
    @Test
    public void test109() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test110() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test111() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test112() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test113() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test114() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test115() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test116() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test117() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test118() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test119() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test120() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test121() {

    }

    /**
     * ================HJ3 明明的随机数======================
     */
    @Test
    public void test122() {

    }
}
